// 元宝平台适配器

class YuanBaoCollector extends DataCollector {
  constructor() {
    super('YuanBao');
    
    // 调用计数器，用于追踪
    this.callId = 0;
    
    // 正在处理的元素集合（用Set存储，防止重复）
    this.processingElements = new Set();
    
    // 全局采集锁（防止多路径同时采集）
    this.isProcessing = false;
    
    // 元宝特定的选择器（基于实际页面）
    this.selectors = {
      chatContainer: '.agent-dialogue__content--common',
      userMessage: '.agent-chat__bubble--human .agent-chat__bubble__content',  // 用户消息（限定在human下）
      userMessageText: '.hyc-content-text',  // 用户消息文本
      aiMessage: '.agent-chat__speech-text--box-left',  // AI消息（外层容器，主选择器）
      aiMessageAlt: '.agent-chat__speech-card',  // AI消息备用（内层卡片）
      messageContent: '.hyc-common-markdown',  // AI消息内容（markdown）
      inputBox: '.ql-editor[contenteditable="true"]',  // contenteditable div
      sendButton: '#yuanbao-send-btn',  // 发送按钮（<a>标签）
      sendButtonDisabledClass: 'style__send-btn--disabled___CGyAQ',  // disabled class
      userAvatar: '.user-info, [class*="avatar"]',
      generating: '[class*="generating"], [class*="typing"], [class*="streaming"]'
    };
  }

  getTargetNode() {
    return document.querySelector(this.selectors.chatContainer) || document.body;
  }

  handleDOMChange(mutations) {
    if (!this.isCollecting) return;

    console.log(`[YuanBao] 🔍 DOM变化批次，共 ${mutations.length} 个变化`);

    for (const mutation of mutations) {
      console.log(`[YuanBao] 🔍 处理变化，新增节点数: ${mutation.addedNodes.length}`);
      
      for (const node of mutation.addedNodes) {
        if (node.nodeType === 1) {
          console.log(`[YuanBao] 🔍 检查节点:`, node.className || node.tagName);
          
          // 方法1：检查节点本身是否是AI消息（支持两个选择器）
          if (node.matches && (
            node.matches(this.selectors.aiMessage) || 
            node.matches(this.selectors.aiMessageAlt)
          )) {
            console.log('[YuanBao] 🔍 方法1：节点匹配AI消息选择器');
            console.log('[YuanBao] 🔍 标记状态:', node.dataset.collected);
            console.log('[YuanBao] 🔍 是否正在处理:', this.processingElements.has(node));
            
            // 三重检查：标记 + 正在处理集合
            if (node.dataset.collected === 'true' || this.processingElements.has(node)) {
              console.log('[YuanBao] ⏭️ 方法1：已标记或正在处理，跳过');
              continue;
            }
            
            console.log('[YuanBao] ✅ 方法1：设置标记和处理标识');
            node.dataset.collected = 'true';
            this.processingElements.add(node);
            
            // 同时标记所有子元素（防止方法2检测到子元素）
            const childCards = node.querySelectorAll(this.selectors.aiMessageAlt);
            if (childCards.length > 0) {
              console.log(`[YuanBao] ✅ 同时标记 ${childCards.length} 个子元素`);
              childCards.forEach(child => {
                child.dataset.collected = 'true';
                this.processingElements.add(child);
              });
            }
            
            const callId = ++this.callId;
            console.log(`[YuanBao] 📌 DOM变化：检测到AI消息（直接节点），分配ID: ${callId}`);
            this.handleNewAIMessage(node, callId);
            return;
          }
          
          // 方法2：检查子节点中是否有AI消息
          let aiMessages = node.querySelectorAll?.(this.selectors.aiMessage);
          if (!aiMessages || aiMessages.length === 0) {
            aiMessages = node.querySelectorAll?.(this.selectors.aiMessageAlt);
          }
          if (aiMessages && aiMessages.length > 0) {
            console.log(`[YuanBao] 🔍 方法2：在子节点中找到 ${aiMessages.length} 个AI消息`);
            
            // 检查所有找到的消息，处理未标记的
            let processed = false;
            for (const aiMsg of aiMessages) {
              // 检查父元素是否已处理（防止父子元素重复）
              const parentBox = aiMsg.closest(this.selectors.aiMessage);
              const isParentProcessed = parentBox && (
                parentBox.dataset.collected === 'true' || 
                this.processingElements.has(parentBox)
              );
              
              console.log('[YuanBao] 🔍 AI消息标记状态:', aiMsg.dataset.collected);
              console.log('[YuanBao] 🔍 是否正在处理:', this.processingElements.has(aiMsg));
              console.log('[YuanBao] 🔍 父元素已处理:', isParentProcessed);
              
              // 跳过已处理的或父元素已处理的
              if (aiMsg.dataset.collected === 'true' || 
                  this.processingElements.has(aiMsg) ||
                  isParentProcessed) {
                console.log('[YuanBao] ⏭️ 方法2：已标记/正在处理/父元素已处理，跳过');
                continue;
              }
              
              console.log('[YuanBao] ✅ 方法2：设置标记和处理标识');
              aiMsg.dataset.collected = 'true';
              this.processingElements.add(aiMsg);
              
              // 同时标记父元素（如果存在）
              if (parentBox && parentBox !== aiMsg) {
                parentBox.dataset.collected = 'true';
                this.processingElements.add(parentBox);
                console.log('[YuanBao] ✅ 同时标记父元素');
              }
              
              const callId = ++this.callId;
              console.log(`[YuanBao] 📌 DOM变化：检测到AI消息（子节点），分配ID: ${callId}`);
              this.handleNewAIMessage(aiMsg, callId);
              processed = true;
              break;  // 只处理第一个未处理的
            }
            
            if (processed) {
              return;  // 处理完立即返回
            }
          }
          
          // 方法3：检查是否是markdown内容更新
          if (node.matches && node.matches(this.selectors.messageContent)) {
            console.log('[YuanBao] 🔍 方法3：节点是markdown内容');
            
            // 找到最顶层的AI消息容器（优先外层）
            let messageParent = node.closest(this.selectors.aiMessage);
            if (!messageParent) {
              messageParent = node.closest(this.selectors.aiMessageAlt);
            }
            
            if (messageParent) {
              console.log('[YuanBao] 🔍 找到父级AI消息，标记状态:', messageParent.dataset.collected);
              console.log('[YuanBao] 🔍 是否正在处理:', this.processingElements.has(messageParent));
              
              // 三重检查：标记 + 正在处理集合
              if (messageParent.dataset.collected === 'true' || this.processingElements.has(messageParent)) {
                console.log('[YuanBao] ⏭️ 方法3：已标记或正在处理，跳过');
                continue;
              }
              
              console.log('[YuanBao] ✅ 方法3：设置标记和处理标识');
              messageParent.dataset.collected = 'true';
              this.processingElements.add(messageParent);
              
              // 同时标记所有相关元素（父子都标记）
              const relatedBox = messageParent.closest(this.selectors.aiMessage);
              if (relatedBox && relatedBox !== messageParent) {
                relatedBox.dataset.collected = 'true';
                this.processingElements.add(relatedBox);
                console.log('[YuanBao] ✅ 同时标记外层父元素');
              }
              const childCards = messageParent.querySelectorAll(this.selectors.aiMessageAlt);
              if (childCards.length > 0) {
                childCards.forEach(child => {
                  child.dataset.collected = 'true';
                  this.processingElements.add(child);
                });
                console.log(`[YuanBao] ✅ 同时标记 ${childCards.length} 个子元素`);
              }
              
              const callId = ++this.callId;
              console.log(`[YuanBao] 📌 DOM变化：markdown内容更新，分配ID: ${callId}`);
              this.handleNewAIMessage(messageParent, callId);
              return;
            }
          }
        }
      }
    }
    
    console.log('[YuanBao] 🔍 本批次DOM变化处理完毕');
  }

  async handleNewAIMessage(element, callId = 0) {
    console.log(`[YuanBao] 🚀 #${callId} 进入 handleNewAIMessage`);
    console.log(`[YuanBao] 🚀 #${callId} 元素标记状态:`, element.dataset.collected);
    console.log(`[YuanBao] 🚀 #${callId} 元素类名:`, element.className);
    console.log(`[YuanBao] 🚀 #${callId} 在处理集合中:`, this.processingElements.has(element));
    console.log(`[YuanBao] 🚀 #${callId} 全局采集锁:`, this.isProcessing);
    
    // 全局锁检查（最强防护）
    if (this.isProcessing) {
      console.log(`[YuanBao] 🔒 #${callId} 有其他采集任务正在进行，跳过`);
      return;
    }
    
    // 设置全局锁
    this.isProcessing = true;
    console.log(`[YuanBao] 🔒 #${callId} 设置全局采集锁`);
    
    try {
      // 三重检查（最后防线）
      if (!this.processingElements.has(element)) {
        console.log(`[YuanBao] ⚠️ #${callId} 元素不在处理集合中，添加`);
        this.processingElements.add(element);
      }
      
      if (element.dataset.collected !== 'true') {
        console.log(`[YuanBao] ⚠️ #${callId} 标记未设置，立即设置`);
        element.dataset.collected = 'true';
      }

      console.log(`[YuanBao] #${callId} 检测到新的AI消息`);

      await this.waitForMessageComplete(element);

      console.log(`[YuanBao] #${callId} AI消息已完成，开始提取数据`);

      const conversation = this.extractConversation();
      if (conversation) {
        console.log(`[YuanBao] #${callId} 数据提取成功，准备保存`);
        console.log(`[YuanBao] #${callId} 📝 问题:`, conversation.userMessage?.substring(0, 30));
        console.log(`[YuanBao] #${callId} 📝 回答:`, conversation.aiResponse?.substring(0, 30));
        console.log(`[YuanBao] #${callId} 📝 格式化HTML:`, conversation.aiResponseHTML ? '已保留' : '无');
        await this.saveData(conversation);
        console.log(`[YuanBao] #${callId} ✅ 数据已保存完成`);
      } else {
        console.warn(`[YuanBao] #${callId} 数据提取失败`);
      }
      
      // 处理完成后从集合中移除
      this.processingElements.delete(element);
      console.log(`[YuanBao] #${callId} 从处理集合中移除元素`);
      
      console.log(`[YuanBao] #${callId} 🏁 handleNewAIMessage 执行完毕`);
    } finally {
      // 释放全局锁
      this.isProcessing = false;
      console.log(`[YuanBao] 🔓 #${callId} 释放全局采集锁`);
    }
  }

  async waitForMessageComplete(element, maxWait = 180000) {  // 增加到3分钟
    const startTime = Date.now();
    
    console.log('[YuanBao] 开始等待消息生成完成...');
    console.log('[YuanBao] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2;
    
    console.log(`[YuanBao] 配置：内容稳定 ${waitSeconds} 秒后采集`);
    
    return new Promise((resolve) => {
      let lastContent = '';
      let stableCount = 0;
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每10秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 10 === 0 && elapsed % 1000 < 500) {
          console.log(`[YuanBao] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((maxWait - elapsed) / 1000)} 秒`);
        }
        
        // 检查内容是否还在变化（使用extractMessageContent提取）
        const currentContent = this.extractMessageContent(element);
        const contentStable = currentContent === lastContent;
        
        if (contentStable) {
          stableCount++;
          console.log(`[YuanBao] 内容稳定计数: ${stableCount}/${requiredStableChecks}`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log('[YuanBao] 内容还在变化，长度:', currentContent.length);
        }
        
        // 检查是否还在生成
        const isGenerating = document.querySelector(this.selectors.generating);
        
        // 防止过早采集：如果内容太短（<20字符）且在2分钟内，继续等待
        const isTooShort = currentContent.length < 20;
        const withinTimeLimit = elapsed < 120000;  // 2分钟
        
        if (isTooShort && withinTimeLimit && stableCount >= requiredStableChecks) {
          console.log(`[YuanBao] ⚠️ 内容太短（${currentContent.length}字符），继续等待...`);
          stableCount = 0;  // 重置计数，继续等待
          return;
        }
        
        // 完成条件
        if ((stableCount >= requiredStableChecks && !isGenerating) || elapsed > maxWait) {
          clearInterval(checkInterval);
          
          if (elapsed > maxWait) {
            const totalSeconds = Math.floor(elapsed / 1000);
            console.warn(`[YuanBao] ⚠️ 等待超时（${totalSeconds}秒），强制采集`);
            console.warn('[YuanBao] 当前内容长度:', currentContent.length);
            if (currentContent.length === 0) {
              console.error('[YuanBao] ❌ 超时且无内容，可能采集失败');
            }
          } else {
            const totalSeconds = Math.floor(elapsed / 1000);
            console.log(`[YuanBao] ✅ 消息生成完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          }
          
          resolve();
        }
      }, 500);
    });
  }

  extractConversation() {
    try {
      console.log('[YuanBao] 开始提取对话...');
      
      // 用户消息
      const userMessages = Array.from(document.querySelectorAll(this.selectors.userMessage));
      console.log('[YuanBao] 用户消息数:', userMessages.length);
      
      // AI消息 - 尝试两个选择器
      let aiMessages = Array.from(document.querySelectorAll(this.selectors.aiMessage));
      if (aiMessages.length === 0) {
        console.log('[YuanBao] 尝试备用AI选择器...');
        aiMessages = Array.from(document.querySelectorAll(this.selectors.aiMessageAlt));
      }
      console.log('[YuanBao] AI消息数:', aiMessages.length);

      if (userMessages.length === 0 || aiMessages.length === 0) {
        console.warn('[YuanBao] 消息数量不足');
        console.log('[YuanBao] 调试信息:');
        console.log('  - 用户消息选择器:', this.selectors.userMessage);
        console.log('  - AI消息选择器:', this.selectors.aiMessage);
        console.log('  - AI备用选择器:', this.selectors.aiMessageAlt);
        return null;
      }

      const lastUserMsg = userMessages[userMessages.length - 1];
      const lastAiMsg = aiMessages[aiMessages.length - 1];

      // 提取内容
      const userContent = this.extractMessageContent(lastUserMsg, true);  // 用户消息
      const aiContent = this.extractMessageContent(lastAiMsg, false);     // AI消息

      console.log('[YuanBao] 用户消息:', userContent.substring(0, 50));
      console.log('[YuanBao] AI回答:', aiContent.substring(0, 100));

      if (!userContent || !aiContent) {
        console.warn('[YuanBao] 内容为空');
        console.log('[YuanBao] 用户消息元素:', lastUserMsg);
        console.log('[YuanBao] AI消息元素:', lastAiMsg);
        return null;
      }

      // 同时提取HTML格式
      const aiHTML = this.extractMessageHTML(lastAiMsg, false);
      
      return {
        userMessage: userContent,
        aiResponse: aiContent,
        aiResponseHTML: aiHTML  // 保留原始HTML格式
      };
    } catch (e) {
      console.error('[YuanBao] 提取对话失败:', e);
      return null;
    }
  }
  
  // 提取消息内容（元宝特殊处理）
  extractMessageContent(messageElement, isUserMessage = false) {
    if (!messageElement) return '';
    
    // 用户消息：在 .hyc-content-text 中
    if (isUserMessage) {
      const textContent = messageElement.querySelector(this.selectors.userMessageText);
      if (textContent) {
        return textContent.innerText || textContent.textContent || '';
      }
    }
    
    // AI消息：在 .hyc-common-markdown 容器中
    const markdownContent = messageElement.querySelector(this.selectors.messageContent);
    if (markdownContent) {
      // 使用 innerText 保留格式，去除HTML标签
      return markdownContent.innerText || markdownContent.textContent || '';
    }
    
    // 备用方案：使用整个消息元素
    return messageElement.innerText || messageElement.textContent || '';
  }
  
  // 提取消息HTML格式（保留完整格式）
  extractMessageHTML(messageElement, isUserMessage = false) {
    if (!messageElement) return '';
    
    // 用户消息：简单文本，不需要HTML
    if (isUserMessage) {
      return this.extractMessageContent(messageElement, true);
    }
    
    // AI消息：保留完整HTML
    const markdownContent = messageElement.querySelector(this.selectors.messageContent);
    if (markdownContent) {
      // 克隆元素，清理不需要的部分
      const cloned = markdownContent.cloneNode(true);
      
      // 移除引用标记（数字上标）
      const refs = cloned.querySelectorAll('.hyc-common-markdown__ref-list');
      refs.forEach(ref => ref.remove());
      
      // 返回HTML
      return cloned.innerHTML;
    }
    
    // 备用方案
    return messageElement.innerHTML || '';
  }

  async sendMessage(text) {
    try {
      console.log('\n========== [YuanBao] 开始发送消息 ==========');
      console.log('[YuanBao] 消息内容:', text);
      console.log('[YuanBao] 消息长度:', text.length);
      console.log('[YuanBao] 当前页面URL:', window.location.href);
      console.log('[YuanBao] 当前页面标题:', document.title);
      console.log('[YuanBao] 页面是否可见:', document.visibilityState);
      
      // 1. 找到输入框（contenteditable div）
      console.log('[YuanBao] 步骤1: 查找输入框，选择器:', this.selectors.inputBox);
      const inputBox = await this.waitForElement(this.selectors.inputBox);
      console.log('[YuanBao] ✅ 找到输入框:', inputBox);
      console.log('[YuanBao] 输入框当前内容:', inputBox.textContent);
      console.log('[YuanBao] 输入框contenteditable:', inputBox.contentEditable);
      
      // 2. 清空并聚焦
      console.log('[YuanBao] 步骤2: 清空并聚焦输入框');
      inputBox.innerHTML = '';
      inputBox.focus();
      console.log('[YuanBao] ✅ 输入框已聚焦');
      
      // 3. 设置内容（contenteditable需要用innerHTML或textContent）
      console.log('[YuanBao] 步骤3: 输入文本');
      inputBox.textContent = text;
      
      // 4. 触发所有必要的事件
      ['input', 'change', 'keyup', 'keydown', 'blur', 'focus'].forEach(eventType => {
        const event = new Event(eventType, { bubbles: true, cancelable: true });
        inputBox.dispatchEvent(event);
      });
      
      // 特别触发：文本输入事件
      const inputEvent = new InputEvent('input', {
        bubbles: true,
        cancelable: true,
        inputType: 'insertText',
        data: text
      });
      inputBox.dispatchEvent(inputEvent);
      
      console.log('[YuanBao] ✅ 文本已输入:', text.substring(0, 50) + (text.length > 50 ? '...' : ''));
      console.log('[YuanBao] 输入框最终内容:', inputBox.textContent.substring(0, 50) + (inputBox.textContent.length > 50 ? '...' : ''));
      
      // 5. 等待UI更新（让发送按钮变为可用）
      console.log('[YuanBao] 等待UI更新 (800ms)...');
      await new Promise(resolve => setTimeout(resolve, 800));
      
      // 6. 查找发送按钮（<a>标签）
      console.log('[YuanBao] 步骤4: 查找发送按钮，选择器:', this.selectors.sendButton);
      const sendButton = document.querySelector(this.selectors.sendButton);
      
      if (!sendButton) {
        console.error('[YuanBao] ❌ 未找到发送按钮');
        console.error('[YuanBao] 页面所有a标签:', document.querySelectorAll('a').length);
        console.error('[YuanBao] 页面所有包含send的元素:', document.querySelectorAll('[id*="send"], [class*="send"]').length);
        throw new Error('未找到发送按钮');
      }
      
      console.log('[YuanBao] ✅ 找到发送按钮:', sendButton);
      console.log('[YuanBao] 按钮标签:', sendButton.tagName);
      console.log('[YuanBao] 按钮ID:', sendButton.id);
      console.log('[YuanBao] 按钮class:', sendButton.className);
      
      // 7. 检查是否disabled（通过class检查）
      const isDisabled = sendButton.classList.contains(this.selectors.sendButtonDisabledClass);
      console.log('[YuanBao] 按钮disabled状态:', isDisabled);
      
      if (isDisabled) {
        console.warn('[YuanBao] 发送按钮仍然是禁用状态，再等待一下...');
        await new Promise(resolve => setTimeout(resolve, 500));
        
        // 再次检查
        const stillDisabled = sendButton.classList.contains(this.selectors.sendButtonDisabledClass);
        if (stillDisabled) {
          console.error('[YuanBao] 按钮无法启用，可能输入事件未触发');
          // 强制移除disabled class
          sendButton.classList.remove(this.selectors.sendButtonDisabledClass);
        }
      }
      
      // 8. 点击发送按钮（<a>标签需要特殊处理）
      console.log('[YuanBao] 步骤5: 点击发送按钮');
      
      // 方法1：直接click
      sendButton.click();
      console.log('[YuanBao] ✅ 已执行 click()');
      
      // 方法2：触发鼠标事件
      ['mousedown', 'mouseup', 'click'].forEach(eventType => {
        const event = new MouseEvent(eventType, {
          bubbles: true,
          cancelable: true,
          view: window
        });
        sendButton.dispatchEvent(event);
      });
      console.log('[YuanBao] ✅ 已触发鼠标事件 (mousedown, mouseup, click)');
      
      console.log('[YuanBao] 等待消息发送 (500ms)...');
      await new Promise(resolve => setTimeout(resolve, 500));
      
      console.log('[YuanBao] ========== 消息发送完成 ==========\n');
    } catch (e) {
      console.error('[YuanBao] 发送消息失败:', e);
      console.error('[YuanBao] 错误堆栈:', e.stack);
      throw e;
    }
  }

  async waitForResponse(timeout = 180000) {  // 增加到3分钟
    const startTime = Date.now();
    
    console.log('[YuanBao] 等待AI响应...');
    console.log('[YuanBao] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2;
    
    console.log(`[YuanBao] 配置：内容稳定 ${waitSeconds} 秒后完成`);
    
    return new Promise((resolve, reject) => {
      let lastContent = '';
      let stableCount = 0;
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每15秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 15 === 0 && elapsed % 1000 < 500) {
          console.log(`[YuanBao] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((timeout - elapsed) / 1000)} 秒`);
        }
        
        // 获取所有AI消息
        const aiMessages = document.querySelectorAll(this.selectors.aiMessage);
        
        if (aiMessages.length === 0) {
          console.log('[YuanBao] 还没有AI响应...');
          return;
        }
        
        const lastAiMessage = aiMessages[aiMessages.length - 1];
        const currentContent = lastAiMessage.textContent || '';
        
        if (currentContent === lastContent) {
          stableCount++;
          console.log(`[YuanBao] 响应内容稳定: ${stableCount}/${requiredStableChecks}`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log(`[YuanBao] 响应内容更新: ${currentContent.length} 字符`);
        }
        
        // 检查是否还在生成
        const isGenerating = document.querySelector(this.selectors.generating);
        
        // 防止过早采集：如果内容太短且在时间限制内，继续等待
        const isTooShort = currentContent.length < 20;
        const withinTimeLimit = elapsed < 120000;  // 2分钟
        
        if (isTooShort && withinTimeLimit && stableCount >= requiredStableChecks) {
          console.log(`[YuanBao] ⚠️ 响应内容太短（${currentContent.length}字符），继续等待...`);
          stableCount = 0;  // 重置，继续等待
          return;
        }
        
        // 完成条件
        if (stableCount >= requiredStableChecks && !isGenerating) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.log(`[YuanBao] ✅ 响应完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          resolve();
        }
        
        if (elapsed > timeout) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.warn(`[YuanBao] ⚠️ 等待响应超时（${totalSeconds}秒）`);
          console.warn('[YuanBao] 当前内容长度:', currentContent.length);
          
          // 如果有内容就resolve，没内容就reject
          if (currentContent.length > 0) {
            console.warn('[YuanBao] 有部分内容，继续采集');
            resolve();
          } else {
            console.error('[YuanBao] ❌ 超时且无内容，采集失败');
            reject(new Error('等待响应超时且无内容'));
          }
        }
      }, 500);
    });
  }

  getLatestResponse() {
    const aiMessages = document.querySelectorAll(this.selectors.aiMessage);
    if (aiMessages.length === 0) return null;
    
    const lastMessage = aiMessages[aiMessages.length - 1];
    return this.extractMessageContent(lastMessage);
  }

  isLoggedIn() {
    // 方法1：检查URL
    const url = window.location.href;
    if (url.includes('login') || url.includes('sign')) {
      return false;
    }
    
    // 方法2：检查输入框是否存在（已登录才有）
    const inputBox = document.querySelector(this.selectors.inputBox);
    if (inputBox) {
      console.log('[YuanBao] 检测到输入框，判断为已登录');
      return true;
    }
    
    // 方法3：检查是否有发送按钮
    const sendButton = document.querySelector(this.selectors.sendButton);
    if (sendButton) {
      console.log('[YuanBao] 检测到发送按钮，判断为已登录');
      return true;
    }
    
    // 方法4：检查是否有用户头像
    const userAvatar = document.querySelector(this.selectors.userAvatar);
    if (userAvatar) {
      return true;
    }
    
    // 默认：如果在元宝域名且不在登录页，认为已登录
    return url.includes('yuanbao.tencent.com') && !url.includes('login');
  }
}

const collector = new YuanBaoCollector();
collector.init();

console.log('[YuanBao] 内容脚本已加载');

